import axios from 'axios'
import { ElMessage } from 'element-plus'
import router from '@/router'
import { useUserStore } from '@/store/user'

// 创建axios实例
const service = axios.create({
  baseURL: '/frontend', // 使用相对路径，由Vite代理转发
  timeout: 300000, // 请求超时时间设置为5分钟
  withCredentials: true // 允许携带cookies
})

// 标记是否正在进行登录操作，避免循环重定向
let isLoggingIn = false
// 是否抑制401错误的控制台输出
let suppress401Errors = false

// 请求拦截器
service.interceptors.request.use(
  config => {
    console.log(`请求开始: ${config.method.toUpperCase()} ${config.url}`, config)
    
    const userStore = useUserStore()
    if (userStore.token) {
      // 添加标准的Authorization头
      config.headers['Authorization'] = userStore.token
      
      // 为/common/upload接口添加token参数
      if (config.url && config.url.includes('/common/upload')) {
        config.headers['token'] = userStore.token
      }
    } else {
      console.warn('发送请求没有携带token')
    }
    
    // 统一设置Content-Type
    if (!config.headers['Content-Type']) {
      config.headers['Content-Type'] = 'application/json'
    }
    
    // 对获取用户信息的请求设置错误抑制标记
    if (config.url && config.url.includes('/user/info')) {
      config.suppressError = true
    }
    
    return config
  },
  error => {
    console.error('请求错误:', error)
    ElMessage.error(`请求配置错误: ${error.message}`)
    return Promise.reject(error)
  }
)

// 响应拦截器
service.interceptors.response.use(
  response => {
    // 检查是否是文本/流式响应
    const contentType = response.headers['content-type'] || '';
    const isTextResponse = contentType.includes('text/plain') || 
                          contentType.includes('text/html') || 
                          contentType.includes('text/event-stream') ||
                          (typeof response.data === 'string' && response.data.length > 0);
    
    // 如果是流式文本响应，直接返回文本
    if (isTextResponse) {
      const responseData = typeof response.data === 'string' ? response.data : '';
      // 记录完整响应数据（可能较长，仅显示前100个字符）
      console.log(`响应成功: ${response.config.method.toUpperCase()} ${response.config.url}`, 
                responseData.substring(0, 100) + (responseData.length > 100 ? '...' : ''));
      return responseData;
    }
    
    // 对JSON响应的处理
    const res = response.data;
    console.log(`响应成功: ${response.config.method.toUpperCase()} ${response.config.url}`, res);
    
    // 根据后端返回格式调整成功判断条件
    if (res.code === 200 || res.code === 0) {
      return res;
    }
    
    // 处理特定错误码
    if (res.code === 401 || res.code === 403) {
      const errorMsg = res.message || res.msg || '未登录或登录已过期';
      console.error(`授权错误(${res.code}): ${errorMsg}`, res);
      
      // 显示错误信息但不重定向
      if (!isLoggingIn && !response.config.url.includes('/login') && !response.config.suppressError) {
        ElMessage.error(errorMsg);
      }
      return Promise.reject(new Error(errorMsg));
    }
    
    // 其他错误
    const errorMsg = res.message || res.msg || '请求失败';
    console.error(`业务错误(${res.code}): ${errorMsg}`, res);
    
    if (!response.config.suppressError) {
      ElMessage.error(errorMsg);
    }
    return Promise.reject(new Error(errorMsg));
  },
  error => {
    // 提取响应文本，可能包含有效内容
    let responseText = '';
    try {
      if (error.response && error.response.data) {
        if (typeof error.response.data === 'string') {
          responseText = error.response.data;
        } else if (error.response.data.message || error.response.data.msg) {
          responseText = error.response.data.message || error.response.data.msg;
        }
      } else if (error.request && error.request.responseText) {
        responseText = error.request.responseText;
      }
    } catch (e) {
      console.error('尝试提取响应文本时出错:', e);
    }
    
    // 对于流式响应，如果有响应文本，则返回它，不视为错误
    if (responseText && 
        ((error.config && error.config.responseType === 'text') || 
         (error.response && error.response.headers && error.response.headers['content-type'] && 
          (error.response.headers['content-type'].includes('text/plain') || 
           error.response.headers['content-type'].includes('text/html') ||
           error.response.headers['content-type'].includes('text/event-stream'))))) {
      console.log('从错误中提取到有效的文本响应:', responseText.substring(0, 100) + '...');
      return Promise.resolve(responseText);
    }
    
    // 常规错误处理
    console.error('请求失败:', error);
    console.error('请求配置:', error.config);
    console.error('错误状态:', error.response?.status);
    console.error('错误数据:', error.response?.data);
    
    // 检查是否需要抑制错误输出
    const shouldSuppressError = error.config && error.config.suppressError;
    
    // 处理401错误 (未授权)，但不自动跳转
    if (error.response && error.response.status === 401) {
      if (!isLoggingIn && !error.config.url.includes('/login') && !shouldSuppressError) {
        ElMessage.error('登录已过期，但不会自动跳转，请手动登录');
      }
    }
    // CORS和网络错误
    else if (error.message.includes('Network Error') || (error.response && error.response.status === 0)) {
      if (!shouldSuppressError) {
        if (error.message.includes('CORS') || (error.toString && error.toString().includes('CORS'))) {
          ElMessage.error('跨域请求被阻止，请检查后端CORS配置');
        } else {
          ElMessage.error('网络错误，请检查您的网络连接或后端服务是否正常运行');
        }
      }
    } 
    // 其他错误类型
    else if (!shouldSuppressError) {
      if (error.message.includes('timeout')) {
        ElMessage.error('请求超时，请稍后重试');
      } else if (error.response && error.response.status === 404) {
        ElMessage.error('请求的资源不存在 (404)');
      } else if (error.response && error.response.status >= 500) {
        ElMessage.error('服务器内部错误 (' + error.response.status + ')');
      } else {
        ElMessage.error(error.response?.data?.message || error.response?.data?.msg || error.message || '请求失败');
      }
    }
    
    return Promise.reject(error);
  }
)

// 登录API调用的包装函数，设置登录状态标记
export function setLoggingInStatus(status) {
  isLoggingIn = status
}

// 设置是否抑制401错误的日志输出
export function setSuppressAuthErrors(suppress) {
  suppress401Errors = suppress
}

export default service